package com.jdy.haoduoaiteacher.view;//package com.jdy.haoduoaiteacher.view;
//
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//
//import android.R.color;
//import android.content.Context;
//import android.graphics.Bitmap;
//import android.graphics.Canvas;
//import android.graphics.Color;
//import android.graphics.LinearGradient;
//import android.graphics.Paint;
//import android.graphics.Paint.Style;
//import android.graphics.Path;
//import android.graphics.PointF;
//import android.graphics.Rect;
//import android.graphics.Shader;
//import android.graphics.drawable.Drawable;
//import android.graphics.drawable.LayerDrawable;
//import android.graphics.drawable.ShapeDrawable;
//import android.graphics.drawable.shapes.RoundRectShape;
//import android.util.AttributeSet;
//import android.util.DisplayMetrics;
//import android.util.Log;
//import android.view.MotionEvent;
//import android.view.View;
//
///**
// * Creativity borrowed from smartisan's mute countdown.
// * 
// * @author zp @ 2015-6-2 下午1:44:59
// */
//public class CountDownView extends View {
//
//  DisplayMetrics mDisplayMetrics;
//
//  public DisplayMetrics getmDisplayMetrics() {
//    return mDisplayMetrics;
//  }
//
//  public void setmDisplayMetrics(DisplayMetrics mDisplayMetrics) {
//    this.mDisplayMetrics = mDisplayMetrics;
//
//    updateTextSize();
//  }
//
//  /**
//   * Different type of the face.
//   * 
//   * @author zp @ 2015-6-2 下午3:08:42
//   */
//  private enum FaceType {
//    NONE,
//
//    LINEAR,
//
//    CIRCLE,
//
//  }
//
//  private enum GapPosition {
//    NONE,
//
//    TOP_LEFT,
//
//    TOP_RIGHT,
//
//    BOTTOM_LEFT,
//
//    BOTTOM_RIGHT,
//  }
//
//  private enum AreaPosition {
//    NONE,
//
//    LEFT_MOST,
//
//    RIGHT_MOST,
//
//    MUNDANE,
//  }
//
//  /**
//   * Range of the movement.
//   * 
//   * @author zp @ 2015-6-5 上午10:29:36
//   */
//  private class Range {
//
//    public float Min;
//
//    public float Max;
//
//    public Range(float min, float max) {
//      this.Min = min;
//
//      this.Max = max;
//    }
//
//  }
//
//  /**
//   * Interact with user finger.
//   * 
//   * @author zp @ 2015-6-4 下午8:34:05
//   */
//  private class OptionButtonArea {
//
//    public float InnerRadius;
//
//    public float Radius;
//
//    public PointF Position;
//
//    public int OptionButtonColor = Color.argb(255, 198, 198, 198);
//
//    public int OptionButtonShadowColor = Color.argb(255, 177, 177, 177);
//
//    public int OptionButtonShadowSize = 0;
//
//    public int InnerOptionButtonColor = Color.argb(255, 252, 95, 64);
//
//    public int TimeColor = Color.argb(255, 113, 113, 113);
//
//    public float TIMESTAMP_YOFFSET = 25;
//
//    public Bitmap ButtonBody;
//
//    public Range XRANGE;
//
//    public Range YRANGE;
//
//    public OptionButtonArea(PointF pos, float r) {
//      this.Position = pos;
//
//      this.Radius = r;
//
//      this.InnerRadius = r / 3 + r / 7;
//
//      this.ButtonBody = Bitmap.createBitmap((int) Radius * 2, (int) Radius * 2,
//          Bitmap.Config.ARGB_8888);
//
//      // LayerDrawable ld = makeOptionButtonBackground();
//
//      this.XRANGE = new Range(this.Position.x - Radius, this.Position.x
//          + Radius);
//
//      this.YRANGE = new Range(this.Position.y - Radius, this.Position.y
//          + Radius);
//
//    }
//
//    public void setBoundary(Range xLimit, Range yLimit) {
//      this.XRANGE = xLimit;
//
//      this.YRANGE = yLimit;
//    }
//
//    public boolean contains(int x, int y) {
//      if (x >= this.Position.x - Radius && x <= this.Position.x + Radius
//          && y >= this.Position.y - Radius && y <= this.Position.y + Radius) {
//
//        return true;
//      } else
//        return false;
//    }
//
//    public void setPosition(float x, float y, List<OptionArea> optionAreaList) {
//      if (x < XRANGE.Min) {
//        x = XRANGE.Min;
//      }
//      if (x > XRANGE.Max) {
//        x = XRANGE.Max;
//      }
//      if (y < YRANGE.Min) {
//        y = YRANGE.Min;
//      }
//      if (y > YRANGE.Max) {
//        y = YRANGE.Max;
//      }
//
//      int c = optionAreaList.size();
//
//      for (int i = 0; i < c; i++) {
//        optionAreaList.get(i).contains(x, y);
//      }
//
//      this.Position.x = x;
//      this.Position.y = y;
//    }
//
//    /**
//     * Set discrete position on a list of possible position.
//     * 
//     * @param touchX
//     * @param touchY
//     * @param optionAreaList
//     */
//    public void setDiscretePosition(float touchX, float touchY,
//        List<OptionArea> optionAreaList) {
//      int c = optionAreaList.size();
//      for (int i = 0; i < c; i++) {
//        if (optionAreaList.get(i).contains(touchX, touchY)) {
//          PointF newPos = new PointF(optionAreaList.get(i).Center.x,
//              optionAreaList.get(i).Center.y);
//          this.Position.x = newPos.x;
//          this.Position.y = newPos.y;
//          if (i == 0) {
//            mCountingDown = false;
//            if (mCountDownTimerListener != null)
//              mCountDownTimerListener.onCountDownTimerStop();
//            if (mCountDownTimerListener != null)
//              mCountDownTimerListener.onCountDownTimerStart(
//                  optionAreaList.get(i).TotalMillis, mVelocity, mInitialPos);
//            invalidate();
//            return;
//          } else {
//
//            mCountingDown = true;
//
//            float totalLength = optionAreaList.get(i).Center.x
//                - optionAreaList.get(0).Center.x;
//
//            mInitialPos = optionAreaList.get(0).Center.x;
//
//            mVelocity = totalLength
//                / (optionAreaList.get(i).TotalMillis / 1000);
//
//            mTotalSecondsRemaining = optionAreaList.get(i).TotalMillis / 1000;
//
//            Position.x = mTotalSecondsRemaining * mVelocity + mInitialPos;
//
//            if (mCountDownTimerListener != null)
//              mCountDownTimerListener.onCountDownTimerStart(
//                  optionAreaList.get(i).TotalMillis, mVelocity, mInitialPos);
//          }
//        }
//      }
//    }
//
//    private Bitmap generateBallBitmap(int ballColor, int ballColorShadow,
//        float ballSize, int ballShadowSize) {
//
//      Paint paint = new Paint();
//      paint.setAntiAlias(true);
//      paint.setColor(ballColor);
//      paint.setShadowLayer(ballShadowSize, 0, 3 * ballShadowSize / 2,
//          ballColorShadow);
//
//      Bitmap bitmap = Bitmap.createBitmap(
//          (int) ((ballSize + ballShadowSize) * 2f),
//          (int) ((ballSize + ballShadowSize) * 2f), Bitmap.Config.ARGB_8888);
//      bitmap.eraseColor(Color.TRANSPARENT);
//      Canvas canvas = new Canvas(bitmap);
//      canvas.drawCircle(ballSize, ballSize, ballSize, paint);
//      paint.setShadowLayer(0, 0, 0, 0);
//      paint.setStyle(Style.STROKE);
//      paint.setStrokeWidth(4);
//      paint.setColor(color.black);
//      canvas.drawCircle(ballSize, ballSize, ballSize + 4, paint);
//      return bitmap;
//    }
//
//    public void draw(Canvas canvas) {
//      Paint paint = new Paint();
//      paint.setFlags(Paint.ANTI_ALIAS_FLAG);
//      paint.setColor(OptionBackgroundColor);
//      paint.setStyle(Paint.Style.STROKE);
//      canvas.drawCircle(this.Position.x, this.Position.y, Radius + 1, paint);
//
//      paint.setColor(OptionButtonColor);
//      paint.setStyle(Paint.Style.FILL);
//      // paint.setShadowLayer(2.0f, 0.0f, 2.0f, 0xFF000000);
//      canvas.drawCircle(this.Position.x, this.Position.y, Radius, paint);
//
//      // if (mOptionButtonBitmap == null) {
//      // mOptionButtonBitmap = generateBallBitmap(OptionButtonColor,
//      // OptionButtonShadowColor, Radius, OptionButtonShadowSize);
//      // }
//      // canvas.drawBitmap(mOptionButtonBitmap, this.Position.x - Radius,
//      // this.Position.y - Radius, null);
//
//      paint.setColor(0xfff6b559/* InnerOptionButtonColor */);
//      if (mDrawCountDownProgress && mCountingDown && !mSelected) {
//        // canvas.drawCircle(this.Position.x, this.Position.y, InnerRadius / 2,
//        // paint);
//        paint.setColor(TimeColor);
//        paint.setTextSize(DescriptionTextSize);
//        // String timeStamp = String.format("%02d:%02d:%02d", mHoursRemaining
//        // ,mMinuteRemaining, mSecondsRemaining);
//        Rect bounds = new Rect();
//        paint.getTextBounds(mCurrentTimeStamp, 0, mCurrentTimeStamp.length(),
//            bounds);
//        int width = bounds.width();
//        int height = bounds.height();
//        canvas.drawText(mCurrentTimeStamp, this.Position.x - width / 2,
//            this.Position.y - height - TIMESTAMP_YOFFSET, paint);
//
//      } else
//        canvas.drawCircle(this.Position.x, this.Position.y, Radius, paint);
//    }
//  }
//
//  /**
//   * Option area.
//   * 
//   * @author zp @ 2015-6-2 下午3:08:26
//   */
//  private class OptionArea {
//
//    private final int Order;// start form zero.
//
//    public AreaPosition GlobePositon;
//
//    public PointF Center;
//
//    public float Width;
//
//    public float InnerRadius = 4;
//
//    public float OutterRadius = 15;
//
//    public float GapHeight = 6;
//
//    public String Description;
//
//    public double GapAngle;
//
//    public Range XAreaRange;
//
//    public Range YAreaRange;
//
//    public static final int SAMPLE_COUNT = 20;
//
//    public boolean Activate = false;
//
//    public long TotalMillis;
//
//    public OptionArea(int i) {
//      this.Width = CurrentWidth / (OPTIONS_COUNT);
//      this.InnerRadius = this.Width / 24;
//      this.OutterRadius = this.Width / 8;
//      this.GapHeight = this.OutterRadius / 3;
//      this.Order = i;
//      this.Center = new PointF();
//      this.Center.x = XOffset + (2 * Order + 1) * Width / 2;
//      this.Center.y = YOffset + Width / 2;
//      double d = GapHeight / (2 * OutterRadius);
//      GapAngle = Math.asin(d);
//      XAreaRange = new Range(this.Center.x - this.Width / 2, this.Center.x
//          + this.Width / 2);
//      YAreaRange = new Range(this.Center.y - this.Width / 2, this.Center.y
//          + this.Width / 2);
//    }
//
//    public boolean contains(float x, float y) {
//      if (x <= XAreaRange.Max && x >= XAreaRange.Min && y <= YAreaRange.Max
//          && y >= YAreaRange.Min) {
//        this.Activate = true;
//        return true;
//      } else {
//        this.Activate = false;
//        return false;
//      }
//    }
//
//    /**
//     * Get arc points
//     * 
//     * @param upward
//     * @return
//     */
//    public PointF[] getArcPoints(boolean upward) {
//      switch (this.GlobePositon) {
//      case MUNDANE:
//        return this.getArcPoints(upward, false, false);
//      case LEFT_MOST:
//        return this.getArcPoints(upward, true, false);
//      case RIGHT_MOST:
//        return this.getArcPoints(upward, false, true);
//      default:
//        return null;
//      }
//    }
//
//    /**
//     * Here is the implicit assumption of the order: upward: from left to right
//     * downward:from right to left
//     * 
//     * handle null exception and mislead neighbor
//     * 
//     * @param upward
//     * @param neighbor
//     * @return
//     */
//    public PointF[] getNeigborPoints(boolean upward, OptionArea neighbor) {
//      if (neighbor == null)
//        return new PointF[] {};
//
//      if (upward) {
//        return new PointF[] { this.getGapPoint(GapPosition.TOP_RIGHT),
//            neighbor.getGapPoint(GapPosition.TOP_LEFT), };
//      } else {
//        return new PointF[] { this.getGapPoint(GapPosition.BOTTOM_LEFT),
//            neighbor.getGapPoint(GapPosition.BOTTOM_LEFT), };
//      }
//    }
//
//    /**
//     * Get arc points to compose complicated graph. Six different situations.
//     * 
//     * @param upward
//     *          or downward
//     * @param leftClosed
//     *          check if left handside of the circle is closed or not.
//     * @param rightClosed
//     *          check if right handside of the circle is closed or not.
//     * @return
//     */
//    public PointF[] getArcPoints(boolean upward, boolean leftClosed,
//        boolean rightClosed) {
//
//      if (upward && leftClosed && !rightClosed) {
//        return getPointsByAngleRange(Math.PI, Math.PI * 2 - GapAngle,
//            SAMPLE_COUNT);
//      } else if (!upward && leftClosed && !rightClosed) {
//        return getPointsByAngleRange(GapAngle, Math.PI, SAMPLE_COUNT);
//      } else if (upward && !leftClosed && !rightClosed) {
//        return getPointsByAngleRange(Math.PI + GapAngle,
//            2 * Math.PI - GapAngle, SAMPLE_COUNT);
//      } else if (!upward && !leftClosed && !rightClosed) {
//        return getPointsByAngleRange(GapAngle, Math.PI * 2 - GapAngle,
//            SAMPLE_COUNT);
//      } else if (upward && !leftClosed && rightClosed) {
//        return getPointsByAngleRange(Math.PI + GapAngle, 2 * Math.PI,
//            SAMPLE_COUNT);
//      } else if (!upward && !leftClosed && rightClosed) {
//        return getPointsByAngleRange(0, Math.PI - GapAngle, SAMPLE_COUNT);
//      }
//
//      return null;
//    }
//
//    /**
//     * 
//     * @param gaptype
//     *          there are four different type of position for gap point.
//     * @return
//     */
//    public PointF getGapPoint(GapPosition gaptype) {
//      switch (gaptype) {
//      case TOP_LEFT:
//        return getPointByAngle(this.GapAngle + Math.PI);
//      case TOP_RIGHT:
//        return getPointByAngle(-this.GapAngle);
//      case BOTTOM_RIGHT:
//        return getPointByAngle(this.GapAngle);
//      case BOTTOM_LEFT:
//        return getPointByAngle(Math.PI - this.GapAngle);
//      default:
//        return null;
//      }
//    }
//
//    /**
//     * Get an array of points by a given range of angle.
//     * 
//     * @param start
//     * @param end
//     * @param samples
//     * @return
//     */
//    private PointF[] getPointsByAngleRange(double start, double end, int samples) {
//      double range = end - start;
//      double step = range / samples;
//      List<PointF> points = new ArrayList<PointF>();
//      double c = start;
//      for (; c <= end; c += step) {
//        PointF n = getPointByAngle(c);
//        points.add(n);
//      }
//      return points.toArray(new PointF[points.size()]);
//    }
//
//    /**
//     * Get point from the circle by a certain angle.
//     */
//    private PointF getPointByAngle(double rotateAngle) {
//      PointF p = new PointF();
//      p.x = this.Center.x + OutterRadius * (float) Math.cos(rotateAngle);
//      p.y = this.Center.y + OutterRadius * (float) Math.sin(rotateAngle);
//      return p;
//    }
//
//    public void draw(Canvas canvas) {
//      // draw inner solid dot circle
//      Paint paint = new Paint();
//      paint.setStyle(Paint.Style.FILL);
//      paint.setColor(OptionColor);
//      paint.setFlags(Paint.ANTI_ALIAS_FLAG);
//      canvas.drawCircle(this.Center.x, this.Center.y, this.OutterRadius - 1,
//          paint);
//
//      // draw description
//      paint.setColor(DescriptionColor);
//      paint.setTextSize(DescriptionTextSize);
//      float textYOffset = Text_YOffset;
//      if (Activate) {
//        textYOffset = Text_YOffset * 3;
//      }
//      Rect bounds = new Rect();
//      paint.getTextBounds(Description, 0, Description.length(), bounds);
//      int width = bounds.width();
//      int height = bounds.height();
//
//      canvas.drawText(Description, this.Center.x - width / 2, this.Center.y
//          - OutterRadius - height / 2 - textYOffset, paint);
//    }
//  }
//
//  private Bitmap mOptionButtonBitmap;
//
//  private OnCountDownTimerListener mCountDownTimerListener;
//
//  private float CurrentWidth;
//
//  private float CurrentHeight;
//
//  private float XOffset;
//
//  private float YOffset;
//
//  private final FaceType mFaceType = FaceType.LINEAR;
//
//  private static final String TAG = "CountDownView";
//
//  private static final int OPTIONS_COUNT = 5;
//
//  private final int OptionColor = Color.rgb(255, 255, 255);
//
//  private final int OptionBackgroundColor = Color.rgb(200, 200, 200);
//
//  private final int InnerSelectorColor = Color.rgb(122, 122, 255);
//
//  private final int OutterSelectorColor = Color.rgb(255, 255, 255);
//
//  private final int ProgressColor = Color.rgb(72, 196, 198);
//
//  private final int ComplementProgressColor = Color.rgb(160, 160, 160);
//
//  private final int DescriptionColor = Color.rgb(113, 113, 113);// description
//                                                                // of the
//  // text above the
//  // option.
//
//  private int DescriptionTextSize = 30;
//
//  private static float Text_XOffset = 0;
//
//  private static float Text_YOffset = 4;// in pixel?
//
//  private final float SelectorRadius = 30;
//
//  private final float OptionRectWidth = 50;
//
//  private final float HalfOptionRectWidth = OptionRectWidth / 2;
//
//  private final float OptionCircleRadius = 10;
//
//  private final float OptionInnerCircleRadius = 0;
//
//  private List<OptionArea> mOptionAreaList;
//
//  private String[] DescriptionArrayList;
//
//  private long[] TotalMillisList;
//
//  private List<PointF> mBackgroundPointList;
//
//  private List<PointF> mProgressPointList;
//
//  private List<PointF> mRestProgressPointList;
//
//  private OptionButtonArea mOptionButton;
//
//  private static final long INTERVAL = 1000;// interval of countdown in
//                                            // millisecond
//
//  private boolean mSelected = false;
//
//  private boolean mCountingDown = false;
//
//  private final boolean mDrawCountDownProgress = false;
//
//  private long mTotalSecondsRemaining = 0;
//
//  private float mInitialPos = 0;
//
//  private float mVelocity = 0;
//
//  // private CountDownTimer mCountDownTimer;
//
//  private String mCurrentTimeStamp = "";
//
//  public CountDownView(Context context) {
//    this(context, null);
//    updateTextSize();
//  }
//
//  public CountDownView(Context context, AttributeSet attrs) {
//    this(context, attrs, 0);
//    updateTextSize();
//  }
//
//  public CountDownView(Context context, AttributeSet attrs, int defStyle) {
//    super(context, attrs, defStyle);
//    updateTextSize();
//  }
//
//  float RATIO;
//
//  private void updateTextSize() {
//    if (mDisplayMetrics != null) {
//      int screenWidth = mDisplayMetrics.widthPixels;
//      int screenHeight = mDisplayMetrics.heightPixels;
//      float ratioWidth = (float) screenWidth / 1080;
//      float ratioHeight = (float) screenHeight / 1920;
//
//      RATIO = Math.min(ratioWidth, ratioHeight);
//
//      DescriptionTextSize = 30;
//
//      DescriptionTextSize = Math.round(DescriptionTextSize * RATIO);
//    }
//  }
//
//  public void registerCountDownTimerListener(OnCountDownTimerListener ocdtl) {
//    mCountDownTimerListener = ocdtl;
//  }
//
//  public void refreshRemainningSeconds(long totalMillis, long secondsLeft,
//      float velocity, float initialPos) {
//    mTotalSecondsRemaining = secondsLeft;
//
//    if (mDrawCountDownProgress)
//      mOptionButton.Position.x = mTotalSecondsRemaining * velocity + initialPos;
//    else
//      mOptionButton.Position.x = totalMillis * velocity + initialPos;
//
//    int hoursRemaining = (int) secondsLeft / 3600;
//
//    int remainder = (int) secondsLeft - hoursRemaining * 3600;
//
//    int minuteRemaining = remainder / 60;
//
//    int secondsRemaining = remainder - minuteRemaining * 60;
//
//    mCurrentTimeStamp = String.format("%02d:%02d:%02d", hoursRemaining,
//        minuteRemaining, secondsRemaining);
//
//    mCountingDown = true;
//
//    if (mTotalSecondsRemaining == 0) {
//      mCountingDown = false;
//    }
//    invalidate();
//  }
//
//  private LayerDrawable makeOptionButtonBackground() {
//    RoundRectShape rs = new RoundRectShape(new float[] { 12f, 12f, 12f, 12f,
//        12f, 12f, 12f, 12f }, null, null);
//    ShapeDrawable sd = new ShapeDrawable(rs);
//
//    RoundRectShape rss = new RoundRectShape(new float[] { 12f, 12f, 12f, 12f,
//        12f, 12f, 12f, 12f }, null, null);
//    ShapeDrawable sds = new ShapeDrawable(rss);
//    sds.setShaderFactory(new ShapeDrawable.ShaderFactory() {
//
//      @Override
//      public Shader resize(int width, int height) {
//        LinearGradient lg = new LinearGradient(0, 0, 0, height, new int[] {
//            Color.parseColor("#e5e5e5"), Color.parseColor("#e5e5e5"),
//            Color.parseColor("#e5e5e5"), Color.parseColor("#e5e5e5") },
//            new float[] { 0, 0.50f, 0.50f, 1 }, Shader.TileMode.REPEAT);
//        return lg;
//      }
//    });
//
//    LayerDrawable ld = new LayerDrawable(new Drawable[] { sds, sd });
//    ld.setLayerInset(0, 5, 5, 0, 0); // inset the shadow so it doesn't start
//                                     // right at the left/top
//    ld.setLayerInset(1, 0, 0, 5, 5); // inset the top drawable so we can leave a
//                                     // bit of space for the shadow to use
//
//    return ld;
//  }
//
//  private void initParameters() {
//    // makeOptionButton();
//
//    this.XOffset = getPaddingLeft();
//    this.YOffset = getPaddingTop();
//    mOptionAreaList = new ArrayList<OptionArea>();
//    DescriptionArrayList = new String[] { "关闭", "15分钟", "30分钟", "1小时", "2小时" };
//
//    TotalMillisList = new long[] { 0, 15 * 60 * 1000, 30 * 60 * 1000,
//        60 * 60 * 1000, 120 * 60 * 1000, };
//
//    int i = 0;
//    for (; i < OPTIONS_COUNT; i++) {
//      OptionArea oa = new OptionArea(i);
//      oa.Description = DescriptionArrayList[i];
//      oa.TotalMillis = TotalMillisList[i];
//      // parameters
//      if (i == 0) {
//        oa.GlobePositon = AreaPosition.LEFT_MOST;
//      } else if (i == OPTIONS_COUNT - 1) {
//        oa.GlobePositon = AreaPosition.RIGHT_MOST;
//      } else {
//        oa.GlobePositon = AreaPosition.MUNDANE;
//      }
//
//      mOptionAreaList.add(oa);
//    }
//
//    this.mBackgroundPointList = parseOptionAreaList();
//
//    this.mProgressPointList = new ArrayList<PointF>();
//
//    this.mRestProgressPointList = new ArrayList<PointF>();
//
//    OptionArea firstOptionArea = mOptionAreaList.get(0);
//
//    OptionArea lastOptionArea = mOptionAreaList.get(OPTIONS_COUNT - 1);
//
//    Range xRange = new Range(firstOptionArea.Center.x, lastOptionArea.Center.x);
//
//    Range yRange = new Range(firstOptionArea.Center.y, lastOptionArea.Center.y);
//
//    PointF initialPos = new PointF(firstOptionArea.Center.x,
//        firstOptionArea.Center.y);
//
//    float initialRadius = firstOptionArea.OutterRadius * 1.0f;
//
//    mOptionButton = new OptionButtonArea(initialPos, initialRadius);
//
//    mOptionButton.setBoundary(xRange, yRange);
//  }
//
//  /**
//   * Get a path running as time goes by.
//   * 
//   * @param leftmost
//   * @param currentOptionButtonArea
//   * @return
//   */
//  private List<PointF> getProgressPointList(OptionArea leftmost,
//      OptionButtonArea currentOptionButtonArea) {
//    List<PointF> progressPath = new ArrayList<PointF>();
//
//    progressPath.addAll(Arrays.asList(leftmost.getArcPoints(true)));
//
//    PointF leftTopRight = leftmost.getGapPoint(GapPosition.TOP_RIGHT);
//
//    PointF rightmostTopLeft = new PointF(currentOptionButtonArea.Position.x,
//        leftTopRight.y);
//
//    progressPath.add(leftTopRight);
//
//    progressPath.add(rightmostTopLeft);
//
//    PointF leftBottomRight = leftmost.getGapPoint(GapPosition.BOTTOM_RIGHT);
//
//    PointF rightmostBottomLeft = new PointF(currentOptionButtonArea.Position.x,
//        leftBottomRight.y);
//
//    progressPath.add(rightmostBottomLeft);
//
//    progressPath.add(leftBottomRight);
//
//    progressPath.addAll(Arrays.asList(leftmost.getArcPoints(false)));
//
//    return progressPath;
//  }
//
//  private List<PointF> getRestProgressPointList(
//      OptionButtonArea currentOptionButtonArea, OptionArea rightmost) {
//    List<PointF> restProgressPath = new ArrayList<PointF>();
//
//    PointF rightMostPointUp = rightmost.getGapPoint(GapPosition.TOP_RIGHT);
//
//    PointF rightMostPointBottom = rightmost
//        .getGapPoint(GapPosition.BOTTOM_RIGHT);
//
//    PointF leftPointUp = new PointF(currentOptionButtonArea.Position.x,
//        rightMostPointUp.y);
//
//    PointF leftPointDown = new PointF(currentOptionButtonArea.Position.x,
//        rightMostPointBottom.y);
//
//    PointF[] rightmostArcPart = rightmost.getPointsByAngleRange(
//        -rightmost.GapAngle, rightmost.GapAngle, OptionArea.SAMPLE_COUNT);
//
//    restProgressPath.add(leftPointUp);
//
//    restProgressPath.addAll(Arrays.asList(rightmostArcPart));
//
//    restProgressPath.add(leftPointDown);
//
//    return restProgressPath;
//  }
//
//  /**
//   * Get a list of background points that will make our option background.
//   * 
//   * @return
//   */
//  private List<PointF> parseOptionAreaList() {
//    List<PointF> backgroundPathList = new ArrayList<PointF>();
//    int i = 0;
//
//    // upward first pass
//    for (; i < OPTIONS_COUNT; i++) {
//      OptionArea currentItem = mOptionAreaList.get(i);
//      backgroundPathList.addAll(Arrays.asList(currentItem.getArcPoints(true)));
//      OptionArea nextItem = null;
//      if (i + 1 < OPTIONS_COUNT) {// jab step further
//        nextItem = mOptionAreaList.get(i + 1);
//      }
//      backgroundPathList.addAll(Arrays.asList(currentItem.getNeigborPoints(
//          true, nextItem)));
//    }
//    i = OPTIONS_COUNT - 1;
//    // downward second pass
//    for (; i > -1; i--) {
//      OptionArea currentItem = mOptionAreaList.get(i);
//      backgroundPathList.addAll(Arrays.asList(currentItem.getArcPoints(false)));
//      OptionArea nextItem = null;
//      if (i - 1 > -1) {// jab step closer
//        nextItem = mOptionAreaList.get(i - 1);
//      }
//      backgroundPathList.addAll(Arrays.asList(currentItem.getNeigborPoints(
//          false, nextItem)));
//    }
//    return backgroundPathList;
//  }
//
//  @Override
//  public void onDraw(Canvas canvas) {
//    super.onDraw(canvas);
//    if (mDrawCountDownProgress) {
//      if (!mCountingDown || (mCountingDown && mSelected))
//        drawOptionBackground(canvas);
//      else if (mCountingDown && !mSelected)
//        drawCountDownProgress(canvas);
//    } else {
//      drawOptionBackground(canvas);
//    }
//    handleSelector(canvas);
//  }
//
//  @Override
//  public boolean onTouchEvent(final MotionEvent event) {
//    boolean handled = false;
//
//    int xTouch;
//
//    int yTouch;
//
//    // get touch event coordinates and make transparent circle from it
//    switch (event.getAction()) {
//    case MotionEvent.ACTION_DOWN:
//
//      xTouch = (int) event.getX(0);
//      yTouch = (int) event.getY(0);
//
//      this.mSelected = mOptionButton.contains(xTouch, yTouch);
//      invalidate();
//      handled = true;
//      break;
//
//    case MotionEvent.ACTION_MOVE:
//
//      Log.w(TAG, "Move");
//      xTouch = (int) event.getX(0);
//      yTouch = (int) event.getY(0);
//
//      if (this.mSelected) {
//        this.mOptionButton.setPosition(xTouch, yTouch, mOptionAreaList);
//      }
//      invalidate();
//      handled = true;
//      break;
//
//    case MotionEvent.ACTION_UP:
//      Log.w(TAG, "Motion Up");
//      xTouch = (int) event.getX(0);
//      yTouch = (int) event.getY(0);
//      this.mOptionButton.setDiscretePosition(xTouch, yTouch, mOptionAreaList);
//      this.mSelected = false;
//      invalidate();
//      handled = true;
//      break;
//
//    case MotionEvent.ACTION_CANCEL:
//      Log.w(TAG, "Motion Cancel");
//      xTouch = (int) event.getX(0);
//      yTouch = (int) event.getY(0);
//      this.mOptionButton.setDiscretePosition(xTouch, yTouch, mOptionAreaList);
//      this.mSelected = false;
//      invalidate();
//      handled = true;
//      break;
//
//    default:
//      // do nothing
//      // xTouch = (int) event.getX(0);
//      // yTouch = (int) event.getY(0);
//      // this.mOptionButton.setDiscretePosition(xTouch, yTouch,
//      // mOptionAreaList);
//      // this.mSelected = false;
//      // this.mCountingDown = !this.mSelected;
//      // handled = true;
//      // invalidate();
//      break;
//    }
//
//    return super.onTouchEvent(event) || handled;
//  }
//
//  /**
//   * draw progress of counting down.
//   * 
//   * @param canvas
//   */
//  private void drawCountDownProgress(Canvas canvas) {
//    // TODO Auto-generated method stub
//    this.mProgressPointList = getProgressPointList(mOptionAreaList.get(0),
//        this.mOptionButton);
//    this.mRestProgressPointList = getRestProgressPointList(mOptionButton,
//        mOptionAreaList.get(OPTIONS_COUNT - 1));
//
//    Path path1 = new Path();
//
//    for (int i = 0; i < this.mProgressPointList.size(); i++) {
//      if (i == 0) {
//        path1.moveTo(this.mProgressPointList.get(i).x,
//            this.mProgressPointList.get(i).y);
//      } else {
//        path1.lineTo(this.mProgressPointList.get(i).x,
//            this.mProgressPointList.get(i).y);
//      }
//    }
//
//    path1.close();
//    Paint paint = new Paint();
//    paint.setAntiAlias(true);
//    paint.setColor(ProgressColor);
//    paint.setStyle(Paint.Style.FILL);
//    canvas.drawPath(path1, paint);
//
//    Path path2 = new Path();
//    for (int i = 0; i < this.mRestProgressPointList.size(); i++) {
//      if (i == 0) {
//        path2.moveTo(this.mRestProgressPointList.get(i).x,
//            this.mRestProgressPointList.get(i).y);
//      } else {
//        path2.lineTo(this.mRestProgressPointList.get(i).x,
//            this.mRestProgressPointList.get(i).y);
//      }
//    }
//    path2.close();
//    paint.setColor(ComplementProgressColor);
//    canvas.drawPath(path2, paint);
//    float cx = mOptionAreaList.get(0).Center.x;
//    float cy = mOptionAreaList.get(0).Center.y;
//    paint.setColor(OptionColor);
//    canvas.drawCircle(cx, cy, OptionInnerCircleRadius, paint);
//  }
//
//  private void handleSelector(Canvas canvas) {
//    // TODO Auto-generated method stub
//    mOptionButton.draw(canvas);
//  }
//
//  /**
//   * Draw all options and text description.
//   * 
//   * @param canvas
//   */
//  private void drawOptionBackground(Canvas canvas) {
//    // TODO Auto-generated method stub
//    Path path = new Path();
//
//    for (int i = 0; i < this.mBackgroundPointList.size(); i++) {
//      if (i == 0) {
//        path.moveTo(this.mBackgroundPointList.get(i).x,
//            this.mBackgroundPointList.get(i).y);
//      } else {
//        path.lineTo(this.mBackgroundPointList.get(i).x,
//            this.mBackgroundPointList.get(i).y);
//      }
//
//    }
//
//    path.close();
//    Paint paint = new Paint();
//    paint.setAntiAlias(true);
//    paint.setColor(OptionBackgroundColor);
//    paint.setStyle(Paint.Style.FILL);
//    // paint.setShader(new LinearGradient(0, 0, 0, getHeight(), Color.WHITE,
//    // Color.rgb(235, 235, 235), TileMode.CLAMP));
//    canvas.drawPath(path, paint);
//    for (int i = 0; i < this.mOptionAreaList.size(); i++) {
//      this.mOptionAreaList.get(i).draw(canvas);
//    }
//  }
//
//  @Override
//  protected void onSizeChanged(int xNew, int yNew, int xOld, int yOld) {
//    super.onSizeChanged(xNew, yNew, xOld, yOld);
//    this.CurrentWidth = xNew;
//    this.CurrentHeight = yNew;
//    initParameters();
//  }
//
//  @Override
//  public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//    int desiredWidth = 500;
//    int desiredHeight = 280;
//
//    int widthMode = MeasureSpec.getMode(widthMeasureSpec);
//    int widthSize = MeasureSpec.getSize(widthMeasureSpec);
//    int heightMode = MeasureSpec.getMode(heightMeasureSpec);
//    int heightSize = MeasureSpec.getSize(heightMeasureSpec);
//
//    int width;
//    int height;
//
//    // Measure Width
//    if (widthMode == MeasureSpec.EXACTLY) {
//      // Must be this size
//      width = widthSize;
//    } else if (widthMode == MeasureSpec.AT_MOST) {
//      // Can't be bigger than...
//      width = Math.min(desiredWidth, widthSize);
//    } else {
//      // Be whatever you want
//      width = desiredWidth;
//    }
//
//    // Measure Height
//    if (heightMode == MeasureSpec.EXACTLY) {
//      // Must be this size
//      height = heightSize;
//    } else if (heightMode == MeasureSpec.AT_MOST) {
//      // Can't be bigger than...
//      height = Math.min(desiredHeight, heightSize);
//    } else {
//      // Be whatever you want
//      height = desiredHeight;
//    }
//
//    // MUST CALL THIS
//    setMeasuredDimension(width, height);
//  }
//
// }
